Exercices Corrigés:Mongo DB

soit la collection suivante:

voyages:[
           { id:'',
	infos:{id,villeDepar,villeArrive,Date,prix,distance}
	     client:{id,nom,prenom},
             taxi:{id,matricule,modele,options:['option1','option2','option3']},
             chouffeur:{id,nom,prenom,permis:[{type:'A',num:'45454'},{type:'B',num:'4444'}]}
             
		}
      ]

1.Créer la collections voyages
2.insérer deux documents dans la collections voyages
3.Afficher la listes des chauffeur qui on un permet type B
4.Afficher les taxi qui ont l'option option3
5.Ajouter option4 au taxi matricule =745CD
6.Ajouter au chauffeur id=45 un permet de type C
7.Supprimer le permet type A du chouffeur id=74
8.Modifier l'option option2 du taxi id=44
9.Changer la date des voyage d'hière à aujourd'hui
10.Afficher les pour chaque type de permis la listes des taxi
11.afficher la liste des villes visité par le client nom=ahmed
12.Afficher la distance parcourit par le taxi matricule=ab74
13.Afficher la listes des taxi utilisé par le client nom=ahmed
14.Afficher le nombre de voyage faite par le chouffeur id=4
15.Affiher le nombre de voyage faite par le client nom=ahmed
16.supprimer le taxi qui un fait un seul voyage
17.Afficher le revenue totale pour le taxi matricule=ab74
18.Afficher le totale des dépense du client id=5

Réponses

1 Créer la collections voyages
db.createCollection("voyages")

2 insérer deux documents dans la collections voyages

db.voyages.insertMany([
  {
    infos: { villeDepar: "Ville1", villeArrive: "Ville2", Date: "2023-10-26", prix: 50, distance: 100 },
    client: { nom: "Client1", prenom: "Prénom1" },
    taxi: { matricule: "Matricule1", modele: "Modèle1", options: ["option1", "option2", "option3"] },
    chauffeur: { nom: "Chauffeur1", prenom: "Prénom1", permis: [{ type: 'A', num: '45454' }, { type: 'B', num: '4444' }] }
  },
  {
    infos: { villeDepar: "Ville3", villeArrive: "Ville4", Date: "2023-10-27", prix: 60, distance: 120 },
    client: { nom: "Client2", prenom: "Prénom2" },
    taxi: { matricule: "Matricule2", modele: "Modèle2", options: ["option2", "option3"] },
    chauffeur: { nom: "Chauffeur2", prenom: "Prénom2", permis: [{ type: 'B', num: '5555' }] }
  }
])

3 Afficher la listes des chauffeur qui on un permet type B
db.voyages.find({ "chauffeur.permis.type": "B" })
4 Afficher les taxi qui ont l'option option3
db.voyages.find({ "taxi.options": "option3" },{"taxi":1})
Solution 2:
```
db.voyages.find({ "taxi.options": 
{$in: ["option3"]} },{"taxi":1})
```

5 Ajouter option4 au taxi matricule =745CD

db.voyages.update({ "taxi.matricule": "745CD" }, 
{ $push: { "taxi.options": "option4" } })

7 Supprimer le permet type A du chouffeur id=74

db.voyages.update({ "chauffeur.id": "74" },
 { $pull: { "chauffeur.permis":{$elemMatch:{ type: 'A' } }}})

8 Modifier l'option option2 du taxi id=44 par option4

db.voyages.update({ "taxi.id": "74" },
 { $set: { "taxi.options.$[valeur]":"option4"}},
{arrayFilters:[{"valeur":{$eq:"option2"}}]})

9 Changer la date des voyage d'hière à aujourd'hui

db.voyages.update({ "infos.date": {$eq: new Date(new Date()-1)} },
 { $set: { "infos.date":new Date()}})

10 Afficher pour chaque type de permis la listes des taxi
```
db.voyages.aggregate([
  { $unwind: "$chauffeur.permis" },
  { $group: { _id: "$chauffeur.permis.type", listeTaxis: { $addToSet: "$taxi.matricule" } } }
])
```
listeTaxis: { $addToSet: "$taxi.matricule" }
listeTaxis : est une variable qui de type tableau , à chaque $group , on ajouter $taxi.matricule dans la variable listeTaxis

11 afficher la liste des villes visité par le client nom=ahmed

db.voyages.find({ "client.nom": "ahmed" },
 { "infos.villeDepar": 1, "infos.villeArrive": 1, _id: 0 })

12 Afficher la distance parcourit par le taxi matricule=ab74

db.voyages.aggregate([
  { $match: { "taxi.matricule": "ab74" } },
  { $group: { _id: null, distanceTotale: { $sum: "$infos.distance" } } }
])

13 Afficher la listes des taxi utilisé par le client nom=ahmed

db.voyages.distinct("taxi.matricule", { "client.nom": "ahmed" })

14 Afficher le nombre de voyage faite par le chouffeur id=4
```
db.voyages.find({ "chauffeur._id": "4" }).count()
```
15 Affiher le nombre de voyage faite par le client nom=ahmed
```
db.voyages.find({ "client.nom": "Ahmed" }).count()
```

16 Supprimer le taxi qui un fait un seul voyage

db.voyages.aggregate([
{$group:{_id:"$taxi._id",nombreVoyage:{$sum:1}}},
{$match:{"nombreVoyage":{$eq:1}}},
{$unset:["taxi"]}	
])

17 Afficher le revenue totale pour le taxi matricule=ab74

db.voyages.aggregate([
{$match:{"taxi.matricule":"ab74"}},
{$group:{_id:null,nombreVoyage:{$sum:"infos.prix"}}}	
])

18 Afficher le totale des dépense du client id=5

db.voyages.aggregate([
{$match:{"client._id":"5"}},
{$group:{_id:null,depenses:{$sum:"infos.prix"}}}	
])

Exemples

Trouvez tous les voyages dont le prix est supérieur à 100 €.
```
db.voyages.find({ "infos.prix": { $gt: 100 } });
```
Trouvez tous les voyages effectués par un client nommé "John Doe".
```
db.voyages.find({ "client.nom": "John Doe" });
```
Trouvez tous les voyages effectués en utilisant un taxi de modèle "Sedan".
```
db.voyages.find({ "taxi.modele": "Sedan" });
```
Obtenez la liste distincte des villes de départ.
```
db.voyages.distinct("infos.villeDepar");
```
Comptez le nombre de voyages effectués par un client nommé "Alice".
```
db.voyages.count({ "client.nom": "Alice" });
```

Calculez la somme totale des prix de tous les voyages.

db.voyages.aggregate([{ $group: { _id: null, totalPrix: { $sum: "$infos.prix" } } }]);

Obtenez la liste des modèles de taxi utilisés dans les voyages, sans doublons.

db.voyages.aggregate([{ $group: { _id: null, modeles: { $addToSet: "$taxi.modele" } } }]);

Mettez à jour tous les voyages effectués avant 2023 en leur ajoutant une option "WiFi".

db.voyages.updateMany(
  { "infos.Date": { $lt: new Date("2023-01-01") } },
  { $push: { "taxi.options": "WiFi" } }
);

Supprimez tous les voyages effectués par un chauffeur ayant le nom "Smith".
```
db.voyages.deleteMany({ "chouffeur.nom": "Smith" });
```
Trouvez tous les voyages effectués par un chauffeur qui possède un permis de type "B" avec le numéro "4444".
```
db.voyages.find({ "chouffeur.permis": { $elemMatch: { type: "B", num: "4444" } } });
```

Calculez le nombre de voyages effectués par chaque client.

db.voyages.aggregate([
    { $group: { _id: "$client.nom", totalVoyages: { $sum: 1 } } }
]);

Calculez la distance totale parcourue pour chaque modèle de taxi.

db.voyages.aggregate([
    { $group: { _id: "$taxi.modele", totalDistance: { $sum: "$infos.distance" } } }
]);

Supprimez tous les voyages dont la date est antérieure à "2022-01-01" et dont le prix est inférieur à 50 €.

db.voyages.deleteMany({
    $and: [
        { "infos.Date": { $lt: new Date("2022-01-01") } },
        { "infos.prix": { $lt: 50 } }
    ]
});

Trouvez tous les voyages effectués par un chauffeur qui possède un permis de type "A" avec le numéro "45454" et un permis de type "B" avec le numéro "4444".

db.voyages.find({
    "chouffeur.permis": {
        $elemMatch: { type: "A", num: "45454" }
    },
    "chouffeur.permis": {
        $elemMatch: { type: "B", num: "4444" }
    }
});

Trouvez tous les voyages dont le chauffeur possède un permis de type "A" ou un permis de type "B avec le numéro "4444".

db.voyages.find({
    $or: [
        { "chouffeur.permis": { $elemMatch: { type: "A" } } },
        { "chouffeur.permis": { $elemMatch: { type: "B", num: "4444" } }
        }
    ]
});

Trouvez tous les voyages effectués entre deux dates spécifiques, par exemple, du 2022-05-01 au 2022-05-10.

db.voyages.find({
    "infos.Date": {
        $gte: new Date("2022-05-01"),
        $lte: new Date("2022-05-10")
    }
});

Questions avec Trouvez tous les voyages dont le chauffeur possède un permis de type "A".
```
db.voyages.find({ "chouffeur.permis.type": "A" });
```
Comptez le nombre total de voyages dans la collection.
```
db.voyages.count();
```

Mettez à jour le matricule de tous les taxis de modèle "SUV" en utilisant le matricule "XYZ123".

db.voyages.updateMany(
    { "taxi.modele": "SUV" },
    { $set: { "taxi.matricule": "XYZ123" } }
);

Trouvez tous les voyages effectués par un chauffeur qui possède à la fois un permis de type "A" et un permis de type "B".

db.voyages.find({
    "chouffeur.permis": {
        $elemMatch: { type: "A" }
    },
    "chouffeur.permis": {
        $elemMatch: { type: "B" }
    }
});

Pour chaque voyage, associez les informations du client, du taxi et du chauffeur en utilisant $lookup.

db.voyages.aggregate([
    {
        $lookup: {
            from: "clients",
            localField: "client.id",
            foreignField: "id",
            as: "client_info"
        }
    },
    {
        $lookup: {
            from: "taxis",
            localField: "taxi.id",
            foreignField: "id",
            as: "taxi_info"
        }
    },
    {
        $lookup: {
            from: "chouffeurs",
            localField: "chouffeur.id",
            foreignField: "id",
            as: "chouffeur_info"
        }
    }
]);

Trouvez tous les voyages dont le prix est supérieur à 200 € et indiquez "Coûteux" dans un champ "Catégorie" pour ces voyages. Pour les voyages moins chers, indiquez "Abordable".

db.voyages.aggregate([
    {
        $addFields: {
            Catégorie: {
                $cond: {
                    if: { $gte: ["$infos.prix", 200] },
                    then: "Coûteux",
                    else: "Abordable"
                }
            }
        }
    }
]);

Pour chaque voyage, décomposez le tableau d'options du taxi en plusieurs documents distincts.
```
db.voyages.aggregate([
    { $unwind: "$taxi.options" }
]);
```

Calculez le montant total gagné par chaque chauffeur en additionnant les montants des voyages pour lesquels ils ont conduit.

db.voyages.aggregate([
    {
        $group: {
            _id: "$chouffeur.id",
            totalGagné: { $sum: "$infos.prix" }
        }
    }
]);

Triez tous les voyages par prix, par ordre décroissant, et affichez uniquement les 10 voyages les moins chers.
```
db.voyages.find().sort({ "infos.prix": -1 }).limit(10);
```
Triez tous les voyages par date de départ, par ordre croissant, et affichez les 5 prochains voyages à partir d'aujourd'hui.
```
db.voyages.find({ "infos.Date": { $gte: new Date() } }).sort({ "infos.Date": 1 }).limit(5);
```

Questions avec Mettez à jour les informations de tous les voyages effectués avant 2022-01-01 en augmentant leur prix de 10 % et en ajoutant l'option "Chauffeur privé".

db.voyages.updateMany(
    { "infos.Date": { $lt: new Date("2022-01-01") } },
    [
        { $set: { "infos.prix": { $multiply: ["$infos.prix", 1.1] } } },
        { $push: { "taxi.options": "Chauffeur privé" } }
    ]
);

Trouvez tous les voyages dont la distance est supérieure à 100 km de l'aéroport de Paris.
```
db.voyages.find({
    "infos.distance": { $gt: 100 },
    "infos.villeDepar": "Paris"
});
```
Recherchez tous les voyages contenant le mot "plage" dans leur description en utilisant un texte indexé.
```
db.voyages.find({
    $text: { $search: "plage" }
});
```
Q Mettez à jour le prix de tous les voyages effectués par des chauffeurs ayant un permis de type "A" en ajoutant 5 % au prix initial.
```
db.voyages.updateMany(
    { "chouffeur.permis": { $elemMatch: { type: "A" } } },
    { $mul: { "infos.prix": 1.05 } }
);
```
Recherchez tous les voyages dont le modèle du taxi commence par "Toy".
```
db.voyages.find({ "taxi.modele": { $regex: /^Toy/ } });
```

Mettez à jour le matricule de tous les taxis dont le matricule contient la lettre "X" en remplaçant "X" par "Y".

db.voyages.updateMany(
    { "taxi.matricule": { $regex: /X/ } },
    { $set: { "taxi.matricule": { $regexReplace: { input: "$taxi.matricule", find: /X/, replacement: "Y" } } } }
);